home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / nss / certt.h < prev    next >
C/C++ Source or Header  |  2006-04-20  |  28KB  |  888 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is the Netscape security libraries.
  15.  *
  16.  * The Initial Developer of the Original Code is
  17.  * Netscape Communications Corporation.
  18.  * Portions created by the Initial Developer are Copyright (C) 1994-2000
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *
  23.  * Alternatively, the contents of this file may be used under the terms of
  24.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  25.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26.  * in which case the provisions of the GPL or the LGPL are applicable instead
  27.  * of those above. If you wish to allow use of your version of this file only
  28.  * under the terms of either the GPL or the LGPL, and not to allow others to
  29.  * use your version of this file under the terms of the MPL, indicate your
  30.  * decision by deleting the provisions above and replace them with the notice
  31.  * and other provisions required by the GPL or the LGPL. If you do not delete
  32.  * the provisions above, a recipient may use your version of this file under
  33.  * the terms of any one of the MPL, the GPL or the LGPL.
  34.  *
  35.  * ***** END LICENSE BLOCK ***** */
  36. /*
  37.  * certt.h - public data structures for the certificate library
  38.  *
  39.  * $Id: certt.h,v 1.33 2005/08/17 02:04:12 julien.pierre.bugs%sun.com Exp $
  40.  */
  41. #ifndef _CERTT_H_
  42. #define _CERTT_H_
  43.  
  44. #include "prclist.h"
  45. #include "pkcs11t.h"
  46. #include "seccomon.h"
  47. #include "secmodt.h"
  48. #include "secoidt.h"
  49. #include "plarena.h"
  50. #include "prcvar.h"
  51. #include "nssilock.h"
  52. #include "prio.h"
  53. #include "prmon.h"
  54.  
  55. /* Stan data types */
  56. struct NSSCertificateStr;
  57. struct NSSTrustDomainStr;
  58.  
  59. /* Non-opaque objects */
  60. typedef struct CERTAVAStr                        CERTAVA;
  61. typedef struct CERTAttributeStr                  CERTAttribute;
  62. typedef struct CERTAuthInfoAccessStr             CERTAuthInfoAccess;
  63. typedef struct CERTAuthKeyIDStr                  CERTAuthKeyID;
  64. typedef struct CERTBasicConstraintsStr           CERTBasicConstraints;
  65. #ifdef NSS_CLASSIC
  66. typedef struct CERTCertDBHandleStr               CERTCertDBHandle;
  67. #else
  68. typedef struct NSSTrustDomainStr                 CERTCertDBHandle;
  69. #endif
  70. typedef struct CERTCertExtensionStr              CERTCertExtension;
  71. typedef struct CERTCertKeyStr                    CERTCertKey;
  72. typedef struct CERTCertListStr                   CERTCertList;
  73. typedef struct CERTCertListNodeStr               CERTCertListNode;
  74. typedef struct CERTCertNicknamesStr              CERTCertNicknames;
  75. typedef struct CERTCertTrustStr                  CERTCertTrust;
  76. typedef struct CERTCertificateStr                CERTCertificate;
  77. typedef struct CERTCertificateListStr            CERTCertificateList;
  78. typedef struct CERTCertificateRequestStr         CERTCertificateRequest;
  79. typedef struct CERTCrlStr                        CERTCrl;
  80. typedef struct CERTCrlDistributionPointsStr      CERTCrlDistributionPoints; 
  81. typedef struct CERTCrlEntryStr                   CERTCrlEntry;
  82. typedef struct CERTCrlHeadNodeStr                CERTCrlHeadNode;
  83. typedef struct CERTCrlKeyStr                     CERTCrlKey;
  84. typedef struct CERTCrlNodeStr                    CERTCrlNode;
  85. typedef struct CERTDERCertsStr                   CERTDERCerts;
  86. typedef struct CERTDistNamesStr                  CERTDistNames;
  87. typedef struct CERTGeneralNameStr                CERTGeneralName;
  88. typedef struct CERTGeneralNameListStr            CERTGeneralNameList;
  89. typedef struct CERTIssuerAndSNStr                CERTIssuerAndSN;
  90. typedef struct CERTNameStr                       CERTName;
  91. typedef struct CERTNameConstraintStr             CERTNameConstraint;
  92. typedef struct CERTNameConstraintsStr            CERTNameConstraints;
  93. typedef struct CERTOKDomainNameStr               CERTOKDomainName;
  94. typedef struct CERTPrivKeyUsagePeriodStr         CERTPrivKeyUsagePeriod;
  95. typedef struct CERTPublicKeyAndChallengeStr      CERTPublicKeyAndChallenge;
  96. typedef struct CERTRDNStr                        CERTRDN;
  97. typedef struct CERTSignedCrlStr                  CERTSignedCrl;
  98. typedef struct CERTSignedDataStr                 CERTSignedData;
  99. typedef struct CERTStatusConfigStr               CERTStatusConfig;
  100. typedef struct CERTSubjectListStr                CERTSubjectList;
  101. typedef struct CERTSubjectNodeStr                CERTSubjectNode;
  102. typedef struct CERTSubjectPublicKeyInfoStr       CERTSubjectPublicKeyInfo;
  103. typedef struct CERTValidityStr                   CERTValidity;
  104. typedef struct CERTVerifyLogStr                  CERTVerifyLog;
  105. typedef struct CERTVerifyLogNodeStr              CERTVerifyLogNode;
  106. typedef struct CRLDistributionPointStr           CRLDistributionPoint;
  107.  
  108. /* CRL extensions type */
  109. typedef unsigned long CERTCrlNumber;
  110.  
  111. /*
  112. ** An X.500 AVA object
  113. */
  114. struct CERTAVAStr {
  115.     SECItem type;
  116.     SECItem value;
  117. };
  118.  
  119. /*
  120. ** An X.500 RDN object
  121. */
  122. struct CERTRDNStr {
  123.     CERTAVA **avas;
  124. };
  125.  
  126. /*
  127. ** An X.500 name object
  128. */
  129. struct CERTNameStr {
  130.     PRArenaPool *arena;
  131.     CERTRDN **rdns;
  132. };
  133.  
  134. /*
  135. ** An X.509 validity object
  136. */
  137. struct CERTValidityStr {
  138.     PRArenaPool *arena;
  139.     SECItem notBefore;
  140.     SECItem notAfter;
  141. };
  142.  
  143. /*
  144.  * A serial number and issuer name, which is used as a database key
  145.  */
  146. struct CERTCertKeyStr {
  147.     SECItem serialNumber;
  148.     SECItem derIssuer;
  149. };
  150.  
  151. /*
  152. ** A signed data object. Used to implement the "signed" macro used
  153. ** in the X.500 specs.
  154. */
  155. struct CERTSignedDataStr {
  156.     SECItem data;
  157.     SECAlgorithmID signatureAlgorithm;
  158.     SECItem signature;
  159. };
  160.  
  161. /*
  162. ** An X.509 subject-public-key-info object
  163. */
  164. struct CERTSubjectPublicKeyInfoStr {
  165.     PRArenaPool *arena;
  166.     SECAlgorithmID algorithm;
  167.     SECItem subjectPublicKey;
  168. };
  169.  
  170. struct CERTPublicKeyAndChallengeStr {
  171.     SECItem spki;
  172.     SECItem challenge;
  173. };
  174.  
  175. struct CERTCertTrustStr {
  176.     unsigned int sslFlags;
  177.     unsigned int emailFlags;
  178.     unsigned int objectSigningFlags;
  179. };
  180.  
  181. /*
  182.  * defined the types of trust that exist
  183.  */
  184. typedef enum SECTrustTypeEnum {
  185.     trustSSL = 0,
  186.     trustEmail = 1,
  187.     trustObjectSigning = 2,
  188.     trustTypeNone = 3
  189. } SECTrustType;
  190.  
  191. #define SEC_GET_TRUST_FLAGS(trust,type) \
  192.         (((type)==trustSSL)?((trust)->sslFlags): \
  193.      (((type)==trustEmail)?((trust)->emailFlags): \
  194.       (((type)==trustObjectSigning)?((trust)->objectSigningFlags):0)))
  195.  
  196. /*
  197. ** An X.509.3 certificate extension
  198. */
  199. struct CERTCertExtensionStr {
  200.     SECItem id;
  201.     SECItem critical;
  202.     SECItem value;
  203. };
  204.  
  205. struct CERTSubjectNodeStr {
  206.     struct CERTSubjectNodeStr *next;
  207.     struct CERTSubjectNodeStr *prev;
  208.     SECItem certKey;
  209.     SECItem keyID;
  210. };
  211.  
  212. struct CERTSubjectListStr {
  213.     PRArenaPool *arena;
  214.     int ncerts;
  215.     char *emailAddr;
  216.     CERTSubjectNode *head;
  217.     CERTSubjectNode *tail; /* do we need tail? */
  218.     void *entry;
  219. };
  220.  
  221. /*
  222. ** An X.509 certificate object (the unsigned form)
  223. */
  224. struct CERTCertificateStr {
  225.     /* the arena is used to allocate any data structures that have the same
  226.      * lifetime as the cert.  This is all stuff that hangs off of the cert
  227.      * structure, and is all freed at the same time.  I is used when the
  228.      * cert is decoded, destroyed, and at some times when it changes
  229.      * state
  230.      */
  231.     PRArenaPool *arena;
  232.  
  233.     /* The following fields are static after the cert has been decoded */
  234.     char *subjectName;
  235.     char *issuerName;
  236.     CERTSignedData signatureWrap;    /* XXX */
  237.     SECItem derCert;            /* original DER for the cert */
  238.     SECItem derIssuer;            /* DER for issuer name */
  239.     SECItem derSubject;            /* DER for subject name */
  240.     SECItem derPublicKey;        /* DER for the public key */
  241.     SECItem certKey;            /* database key for this cert */
  242.     SECItem version;
  243.     SECItem serialNumber;
  244.     SECAlgorithmID signature;
  245.     CERTName issuer;
  246.     CERTValidity validity;
  247.     CERTName subject;
  248.     CERTSubjectPublicKeyInfo subjectPublicKeyInfo;
  249.     SECItem issuerID;
  250.     SECItem subjectID;
  251.     CERTCertExtension **extensions;
  252.     char *emailAddr;
  253.     CERTCertDBHandle *dbhandle;
  254.     SECItem subjectKeyID;    /* x509v3 subject key identifier */
  255.     PRBool keyIDGenerated;    /* was the keyid generated? */
  256.     unsigned int keyUsage;    /* what uses are allowed for this cert */
  257.     unsigned int rawKeyUsage;    /* value of the key usage extension */
  258.     PRBool keyUsagePresent;    /* was the key usage extension present */
  259.     PRUint32 nsCertType;    /* value of the ns cert type extension */
  260.                 /* must be 32-bit for PR_AtomicSet */
  261.  
  262.     /* these values can be set by the application to bypass certain checks
  263.      * or to keep the cert in memory for an entire session.
  264.      * XXX - need an api to set these
  265.      */
  266.     PRBool keepSession;            /* keep this cert for entire session*/
  267.     PRBool timeOK;            /* is the bad validity time ok? */
  268.     CERTOKDomainName *domainOK;        /* these domain names are ok */
  269.  
  270.     /*
  271.      * these values can change when the cert changes state.  These state
  272.      * changes include transitions from temp to perm or vice-versa, and
  273.      * changes of trust flags
  274.      */
  275.     PRBool isperm;
  276.     PRBool istemp;
  277.     char *nickname;
  278.     char *dbnickname;
  279.     struct NSSCertificateStr *nssCertificate;    /* This is Stan stuff. */
  280.     CERTCertTrust *trust;
  281.  
  282.     /* the reference count is modified whenever someone looks up, dups
  283.      * or destroys a certificate
  284.      */
  285.     int referenceCount;
  286.  
  287.     /* The subject list is a list of all certs with the same subject name.
  288.      * It can be modified any time a cert is added or deleted from either
  289.      * the in-memory(temporary) or on-disk(permanent) database.
  290.      */
  291.     CERTSubjectList *subjectList;
  292.  
  293.     /* these belong in the static section, but are here to maintain
  294.      * the structure's integrity
  295.      */
  296.     CERTAuthKeyID * authKeyID;  /* x509v3 authority key identifier */
  297.     PRBool isRoot;              /* cert is the end of a chain */
  298.  
  299.     /* these fields are used by client GUI code to keep track of ssl sockets
  300.      * that are blocked waiting on GUI feedback related to this cert.
  301.      * XXX - these should be moved into some sort of application specific
  302.      *       data structure.  They are only used by the browser right now.
  303.      */
  304.     struct SECSocketNode *authsocketlist;
  305.     int series; /* was int authsocketcount; record the series of the pkcs11ID */
  306.  
  307.     /* This is PKCS #11 stuff. */
  308.     PK11SlotInfo *slot;        /*if this cert came of a token, which is it*/
  309.     CK_OBJECT_HANDLE pkcs11ID;    /*and which object on that token is it */
  310.     PRBool ownSlot;        /*true if the cert owns the slot reference */
  311. };
  312. #define SEC_CERTIFICATE_VERSION_1        0    /* default created */
  313. #define SEC_CERTIFICATE_VERSION_2        1    /* v2 */
  314. #define SEC_CERTIFICATE_VERSION_3        2    /* v3 extensions */
  315.  
  316. #define SEC_CRL_VERSION_1        0    /* default */
  317. #define SEC_CRL_VERSION_2        1    /* v2 extensions */
  318.  
  319. /*
  320.  * used to identify class of cert in mime stream code
  321.  */
  322. #define SEC_CERT_CLASS_CA    1
  323. #define SEC_CERT_CLASS_SERVER    2
  324. #define SEC_CERT_CLASS_USER    3
  325. #define SEC_CERT_CLASS_EMAIL    4
  326.  
  327. struct CERTDERCertsStr {
  328.     PRArenaPool *arena;
  329.     int numcerts;
  330.     SECItem *rawCerts;
  331. };
  332.  
  333. /*
  334. ** A PKCS ? Attribute
  335. ** XXX this is duplicated through out the code, it *should* be moved
  336. ** to a central location.  Where would be appropriate?
  337. */
  338. struct CERTAttributeStr {
  339.     SECItem attrType;
  340.     SECItem **attrValue;
  341. };
  342.  
  343. /*
  344. ** A PKCS#10 certificate-request object (the unsigned form)
  345. */
  346. struct CERTCertificateRequestStr {
  347.     PRArenaPool *arena;
  348.     SECItem version;
  349.     CERTName subject;
  350.     CERTSubjectPublicKeyInfo subjectPublicKeyInfo;
  351.     CERTAttribute **attributes;
  352. };
  353. #define SEC_CERTIFICATE_REQUEST_VERSION        0    /* what we *create* */
  354.  
  355.  
  356. /*
  357. ** A certificate list object.
  358. */
  359. struct CERTCertificateListStr {
  360.     SECItem *certs;
  361.     int len;                    /* number of certs */
  362.     PRArenaPool *arena;
  363. };
  364.  
  365. struct CERTCertListNodeStr {
  366.     PRCList links;
  367.     CERTCertificate *cert;
  368.     void *appData;
  369. };
  370.  
  371. struct CERTCertListStr {
  372.     PRCList list;
  373.     PRArenaPool *arena;
  374. };
  375.  
  376. #define CERT_LIST_HEAD(l) ((CERTCertListNode *)PR_LIST_HEAD(&l->list))
  377. #define CERT_LIST_NEXT(n) ((CERTCertListNode *)n->links.next)
  378. #define CERT_LIST_END(n,l) (((void *)n) == ((void *)&l->list))
  379. #define CERT_LIST_EMPTY(l) CERT_LIST_END(CERT_LIST_HEAD(l), l)
  380.  
  381. struct CERTCrlEntryStr {
  382.     SECItem serialNumber;
  383.     SECItem revocationDate;
  384.     CERTCertExtension **extensions;    
  385. };
  386.  
  387. struct CERTCrlStr {
  388.     PRArenaPool *arena;
  389.     SECItem version;
  390.     SECAlgorithmID signatureAlg;
  391.     SECItem derName;
  392.     CERTName name;
  393.     SECItem lastUpdate;
  394.     SECItem nextUpdate;                /* optional for x.509 CRL  */
  395.     CERTCrlEntry **entries;
  396.     CERTCertExtension **extensions;    
  397.     /* can't add anything there for binary backwards compatibility reasons */
  398. };
  399.  
  400. struct CERTCrlKeyStr {
  401.     SECItem derName;
  402.     SECItem dummy;            /* The decoder can not skip a primitive,
  403.                        this serves as a place holder for the
  404.                        decoder to finish its task only
  405.                     */
  406. };
  407.  
  408. struct CERTSignedCrlStr {
  409.     PRArenaPool *arena;
  410.     CERTCrl crl;
  411.     void *reserved1;
  412.     PRBool reserved2;
  413.     PRBool isperm;
  414.     PRBool istemp;
  415.     int referenceCount;
  416.     CERTCertDBHandle *dbhandle;
  417.     CERTSignedData signatureWrap;    /* XXX */
  418.     char *url;
  419.     SECItem *derCrl;
  420.     PK11SlotInfo *slot;
  421.     CK_OBJECT_HANDLE pkcs11ID;
  422.     void* opaque; /* do not touch */
  423. };
  424.  
  425.  
  426. struct CERTCrlHeadNodeStr {
  427.     PRArenaPool *arena;
  428.     CERTCertDBHandle *dbhandle;
  429.     CERTCrlNode *first;
  430.     CERTCrlNode *last;
  431. };
  432.  
  433.  
  434. struct CERTCrlNodeStr {
  435.     CERTCrlNode *next;
  436.     int     type;
  437.     CERTSignedCrl *crl;
  438. };
  439.  
  440.  
  441. /*
  442.  * Array of X.500 Distinguished Names
  443.  */
  444. struct CERTDistNamesStr {
  445.     PRArenaPool *arena;
  446.     int nnames;
  447.     SECItem  *names;
  448.     void *head; /* private */
  449. };
  450.  
  451.  
  452. #define NS_CERT_TYPE_SSL_CLIENT        (0x80)    /* bit 0 */
  453. #define NS_CERT_TYPE_SSL_SERVER        (0x40)  /* bit 1 */
  454. #define NS_CERT_TYPE_EMAIL        (0x20)  /* bit 2 */
  455. #define NS_CERT_TYPE_OBJECT_SIGNING    (0x10)  /* bit 3 */
  456. #define NS_CERT_TYPE_RESERVED        (0x08)  /* bit 4 */
  457. #define NS_CERT_TYPE_SSL_CA        (0x04)  /* bit 5 */
  458. #define NS_CERT_TYPE_EMAIL_CA        (0x02)  /* bit 6 */
  459. #define NS_CERT_TYPE_OBJECT_SIGNING_CA    (0x01)  /* bit 7 */
  460.  
  461. #define EXT_KEY_USAGE_TIME_STAMP        (0x8000)
  462. #define EXT_KEY_USAGE_STATUS_RESPONDER    (0x4000)
  463.  
  464. #define NS_CERT_TYPE_APP ( NS_CERT_TYPE_SSL_CLIENT | \
  465.               NS_CERT_TYPE_SSL_SERVER | \
  466.               NS_CERT_TYPE_EMAIL | \
  467.               NS_CERT_TYPE_OBJECT_SIGNING )
  468.  
  469. #define NS_CERT_TYPE_CA ( NS_CERT_TYPE_SSL_CA | \
  470.              NS_CERT_TYPE_EMAIL_CA | \
  471.              NS_CERT_TYPE_OBJECT_SIGNING_CA | \
  472.              EXT_KEY_USAGE_STATUS_RESPONDER )
  473. typedef enum SECCertUsageEnum {
  474.     certUsageSSLClient = 0,
  475.     certUsageSSLServer = 1,
  476.     certUsageSSLServerWithStepUp = 2,
  477.     certUsageSSLCA = 3,
  478.     certUsageEmailSigner = 4,
  479.     certUsageEmailRecipient = 5,
  480.     certUsageObjectSigner = 6,
  481.     certUsageUserCertImport = 7,
  482.     certUsageVerifyCA = 8,
  483.     certUsageProtectedObjectSigner = 9,
  484.     certUsageStatusResponder = 10,
  485.     certUsageAnyCA = 11
  486. } SECCertUsage;
  487.  
  488. typedef PRInt64 SECCertificateUsage;
  489.  
  490. #define certificateUsageSSLClient              (0x0001)
  491. #define certificateUsageSSLServer              (0x0002)
  492. #define certificateUsageSSLServerWithStepUp    (0x0004)
  493. #define certificateUsageSSLCA                  (0x0008)
  494. #define certificateUsageEmailSigner            (0x0010)
  495. #define certificateUsageEmailRecipient         (0x0020)
  496. #define certificateUsageObjectSigner           (0x0040)
  497. #define certificateUsageUserCertImport         (0x0080)
  498. #define certificateUsageVerifyCA               (0x0100)
  499. #define certificateUsageProtectedObjectSigner  (0x0200)
  500. #define certificateUsageStatusResponder        (0x0400)
  501. #define certificateUsageAnyCA                  (0x0800)
  502.  
  503. #define certificateUsageHighest certificateUsageAnyCA
  504.  
  505. /*
  506.  * Does the cert belong to the user, a peer, or a CA.
  507.  */
  508. typedef enum CERTCertOwnerEnum {
  509.     certOwnerUser = 0,
  510.     certOwnerPeer = 1,
  511.     certOwnerCA = 2
  512. } CERTCertOwner;
  513.  
  514. /*
  515.  * This enum represents the state of validity times of a certificate
  516.  */
  517. typedef enum SECCertTimeValidityEnum {
  518.     secCertTimeValid = 0,
  519.     secCertTimeExpired = 1,
  520.     secCertTimeNotValidYet = 2,
  521.     secCertTimeUndetermined = 3 /* validity could not be decoded from the
  522.                                    cert, most likely because it was NULL */
  523. } SECCertTimeValidity;
  524.  
  525. /*
  526.  * This is used as return status in functions that compare the validity
  527.  * periods of two certificates A and B, currently only
  528.  * CERT_CompareValidityTimes.
  529.  */
  530.  
  531. typedef enum CERTCompareValidityStatusEnum
  532. {
  533.     certValidityUndetermined = 0, /* the function is unable to select one cert 
  534.                                      over another */
  535.     certValidityChooseB = 1,      /* cert B should be preferred */
  536.     certValidityEqual = 2,        /* both certs have the same validity period */
  537.     certValidityChooseA = 3       /* cert A should be preferred */
  538. } CERTCompareValidityStatus;
  539.  
  540. /*
  541.  * Interface for getting certificate nickname strings out of the database
  542.  */
  543.  
  544. /* these are values for the what argument below */
  545. #define SEC_CERT_NICKNAMES_ALL        1
  546. #define SEC_CERT_NICKNAMES_USER        2
  547. #define SEC_CERT_NICKNAMES_SERVER    3
  548. #define SEC_CERT_NICKNAMES_CA        4
  549.  
  550. struct CERTCertNicknamesStr {
  551.     PRArenaPool *arena;
  552.     void *head;
  553.     int numnicknames;
  554.     char **nicknames;
  555.     int what;
  556.     int totallen;
  557. };
  558.  
  559. struct CERTIssuerAndSNStr {
  560.     SECItem derIssuer;
  561.     CERTName issuer;
  562.     SECItem serialNumber;
  563. };
  564.  
  565.  
  566. /* X.509 v3 Key Usage Extension flags */
  567. #define KU_DIGITAL_SIGNATURE        (0x80)    /* bit 0 */
  568. #define KU_NON_REPUDIATION        (0x40)  /* bit 1 */
  569. #define KU_KEY_ENCIPHERMENT        (0x20)  /* bit 2 */
  570. #define KU_DATA_ENCIPHERMENT        (0x10)  /* bit 3 */
  571. #define KU_KEY_AGREEMENT        (0x08)  /* bit 4 */
  572. #define KU_KEY_CERT_SIGN        (0x04)  /* bit 5 */
  573. #define KU_CRL_SIGN            (0x02)  /* bit 6 */
  574. #define KU_ALL                (KU_DIGITAL_SIGNATURE | \
  575.                      KU_NON_REPUDIATION | \
  576.                      KU_KEY_ENCIPHERMENT | \
  577.                      KU_DATA_ENCIPHERMENT | \
  578.                      KU_KEY_AGREEMENT | \
  579.                      KU_KEY_CERT_SIGN | \
  580.                      KU_CRL_SIGN)
  581.  
  582. /* This value will not occur in certs.  It is used internally for the case
  583.  * when the key type is not know ahead of time and either key agreement or
  584.  * key encipherment are the correct value based on key type
  585.  */
  586. #define KU_KEY_AGREEMENT_OR_ENCIPHERMENT (0x4000)
  587.  
  588. /* internal bits that do not match bits in the x509v3 spec, but are used
  589.  * for similar purposes
  590.  */
  591. #define KU_NS_GOVT_APPROVED        (0x8000) /*don't make part of KU_ALL!*/
  592. /*
  593.  * x.509 v3 Basic Constraints Extension
  594.  * If isCA is false, the pathLenConstraint is ignored.
  595.  * Otherwise, the following pathLenConstraint values will apply:
  596.  *    < 0 - there is no limit to the certificate path
  597.  *    0   - CA can issues end-entity certificates only
  598.  *    > 0 - the number of certificates in the certificate path is
  599.  *          limited to this number
  600.  */
  601. #define CERT_UNLIMITED_PATH_CONSTRAINT -2
  602.  
  603. struct CERTBasicConstraintsStr {
  604.     PRBool isCA;            /* on if is CA */
  605.     int pathLenConstraint;        /* maximum number of certificates that can be
  606.                        in the cert path.  Only applies to a CA
  607.                        certificate; otherwise, it's ignored.
  608.                      */
  609. };
  610.  
  611. /* Maximum length of a certificate chain */
  612. #define CERT_MAX_CERT_CHAIN 20
  613.  
  614. /* x.509 v3 Reason Falgs, used in CRLDistributionPoint Extension */
  615. #define RF_UNUSED            (0x80)    /* bit 0 */
  616. #define RF_KEY_COMPROMISE        (0x40)  /* bit 1 */
  617. #define RF_CA_COMPROMISE        (0x20)  /* bit 2 */
  618. #define RF_AFFILIATION_CHANGED        (0x10)  /* bit 3 */
  619. #define RF_SUPERSEDED            (0x08)  /* bit 4 */
  620. #define RF_CESSATION_OF_OPERATION    (0x04)  /* bit 5 */
  621. #define RF_CERTIFICATE_HOLD        (0x02)  /* bit 6 */
  622.  
  623. /* If we needed to extract the general name field, use this */
  624. /* General Name types */
  625. typedef enum CERTGeneralNameTypeEnum {
  626.     certOtherName = 1,
  627.     certRFC822Name = 2,
  628.     certDNSName = 3,
  629.     certX400Address = 4,
  630.     certDirectoryName = 5,
  631.     certEDIPartyName = 6,
  632.     certURI = 7,
  633.     certIPAddress = 8,
  634.     certRegisterID = 9
  635. } CERTGeneralNameType;
  636.  
  637.  
  638. typedef struct OtherNameStr {
  639.     SECItem          name;
  640.     SECItem          oid;
  641. }OtherName;
  642.  
  643.  
  644.  
  645. struct CERTGeneralNameStr {
  646.     CERTGeneralNameType type;        /* name type */
  647.     union {
  648.     CERTName directoryName;         /* distinguish name */
  649.     OtherName  OthName;        /* Other Name */
  650.     SECItem other;                  /* the rest of the name forms */
  651.     }name;
  652.     SECItem derDirectoryName;        /* this is saved to simplify directory name
  653.                        comparison */
  654.     PRCList l;
  655. };
  656.  
  657. struct CERTGeneralNameListStr {
  658.     PRArenaPool *arena;
  659.     CERTGeneralName *name;
  660.     int refCount;
  661.     int len;
  662.     PZLock *lock;
  663. };
  664.  
  665. struct CERTNameConstraintStr {
  666.     CERTGeneralName  name;
  667.     SECItem          DERName;
  668.     SECItem          min;
  669.     SECItem          max;
  670.     PRCList          l;
  671. };
  672.  
  673.  
  674. struct CERTNameConstraintsStr {
  675.     CERTNameConstraint  *permited;
  676.     CERTNameConstraint  *excluded;
  677.     SECItem             **DERPermited;
  678.     SECItem             **DERExcluded;
  679. };
  680.  
  681.  
  682. /* Private Key Usage Period extension struct. */
  683. struct CERTPrivKeyUsagePeriodStr {
  684.     SECItem notBefore;
  685.     SECItem notAfter;
  686.     PRArenaPool *arena;
  687. };
  688.  
  689. /* X.509 v3 Authority Key Identifier extension.  For the authority certificate
  690.    issuer field, we only support URI now.
  691.  */
  692. struct CERTAuthKeyIDStr {
  693.     SECItem keyID;            /* unique key identifier */
  694.     CERTGeneralName *authCertIssuer;    /* CA's issuer name.  End with a NULL */
  695.     SECItem authCertSerialNumber;    /* CA's certificate serial number */
  696.     SECItem **DERAuthCertIssuer;    /* This holds the DER encoded format of
  697.                        the authCertIssuer field. It is used
  698.                        by the encoding engine. It should be
  699.                        used as a read only field by the caller.
  700.                     */
  701. };
  702.  
  703. /* x.509 v3 CRL Distributeion Point */
  704.  
  705. /*
  706.  * defined the types of CRL Distribution points
  707.  */
  708. typedef enum DistributionPointTypesEnum {
  709.     generalName = 1,            /* only support this for now */
  710.     relativeDistinguishedName = 2
  711. } DistributionPointTypes;
  712.  
  713. struct CRLDistributionPointStr {
  714.     DistributionPointTypes distPointType;
  715.     union {
  716.     CERTGeneralName *fullName;
  717.     CERTRDN relativeName;
  718.     } distPoint;
  719.     SECItem reasons;
  720.     CERTGeneralName *crlIssuer;
  721.     
  722.     /* Reserved for internal use only*/
  723.     SECItem derDistPoint;
  724.     SECItem derRelativeName;
  725.     SECItem **derCrlIssuer;
  726.     SECItem **derFullName;
  727.     SECItem bitsmap;
  728. };
  729.  
  730. struct CERTCrlDistributionPointsStr {
  731.     CRLDistributionPoint **distPoints;
  732. };
  733.  
  734. /*
  735.  * This structure is used to keep a log of errors when verifying
  736.  * a cert chain.  This allows multiple errors to be reported all at
  737.  * once.
  738.  */
  739. struct CERTVerifyLogNodeStr {
  740.     CERTCertificate *cert;    /* what cert had the error */
  741.     long error;            /* what error was it? */
  742.     unsigned int depth;        /* how far up the chain are we */
  743.     void *arg;            /* error specific argument */
  744.     struct CERTVerifyLogNodeStr *next; /* next in the list */
  745.     struct CERTVerifyLogNodeStr *prev; /* next in the list */
  746. };
  747.  
  748.  
  749. struct CERTVerifyLogStr {
  750.     PRArenaPool *arena;
  751.     unsigned int count;
  752.     struct CERTVerifyLogNodeStr *head;
  753.     struct CERTVerifyLogNodeStr *tail;
  754. };
  755.  
  756.  
  757. struct CERTOKDomainNameStr {
  758.     CERTOKDomainName *next;
  759.     char              name[1]; /* actual length may be longer. */
  760. };
  761.  
  762.  
  763. typedef SECStatus (PR_CALLBACK *CERTStatusChecker) (CERTCertDBHandle *handle,
  764.                             CERTCertificate *cert,
  765.                             int64 time,
  766.                             void *pwArg);
  767.  
  768. typedef SECStatus (PR_CALLBACK *CERTStatusDestroy) (CERTStatusConfig *handle);
  769.  
  770. struct CERTStatusConfigStr {
  771.     CERTStatusChecker statusChecker;    /* NULL means no checking enabled */
  772.     CERTStatusDestroy statusDestroy;    /* enabled or no, will clean up */
  773.     void *statusContext;        /* cx specific to checking protocol */
  774. };
  775.  
  776. struct CERTAuthInfoAccessStr {
  777.     SECItem method;
  778.     SECItem derLocation;
  779.     CERTGeneralName *location;        /* decoded location */
  780. };
  781.  
  782.  
  783. /* This is the typedef for the callback passed to CERT_OpenCertDB() */
  784. /* callback to return database name based on version number */
  785. typedef char * (*CERTDBNameFunc)(void *arg, int dbVersion);
  786.  
  787. /*
  788.  * types of cert packages that we can decode
  789.  */
  790. typedef enum CERTPackageTypeEnum {
  791.     certPackageNone = 0,
  792.     certPackageCert = 1,
  793.     certPackagePKCS7 = 2,
  794.     certPackageNSCertSeq = 3,
  795.     certPackageNSCertWrap = 4
  796. } CERTPackageType;
  797.  
  798. /*
  799.  * these types are for the PKIX Certificate Policies extension
  800.  */
  801. typedef struct {
  802.     SECOidTag oid;
  803.     SECItem qualifierID;
  804.     SECItem qualifierValue;
  805. } CERTPolicyQualifier;
  806.  
  807. typedef struct {
  808.     SECOidTag oid;
  809.     SECItem policyID;
  810.     CERTPolicyQualifier **policyQualifiers;
  811. } CERTPolicyInfo;
  812.  
  813. typedef struct {
  814.     PRArenaPool *arena;
  815.     CERTPolicyInfo **policyInfos;
  816. } CERTCertificatePolicies;
  817.  
  818. typedef struct {
  819.     SECItem organization;
  820.     SECItem **noticeNumbers;
  821. } CERTNoticeReference;
  822.  
  823. typedef struct {
  824.     PRArenaPool *arena;
  825.     CERTNoticeReference noticeReference;
  826.     SECItem derNoticeReference;
  827.     SECItem displayText;
  828. } CERTUserNotice;
  829.  
  830. typedef struct {
  831.     PRArenaPool *arena;
  832.     SECItem **oids;
  833. } CERTOidSequence;
  834.  
  835.  
  836. /* XXX Lisa thinks the template declarations belong in cert.h, not here? */
  837.  
  838. #include "secasn1t.h"    /* way down here because I expect template stuff to
  839.              * move out of here anyway */
  840.  
  841. SEC_BEGIN_PROTOS
  842.  
  843. extern const SEC_ASN1Template CERT_CertificateRequestTemplate[];
  844. extern const SEC_ASN1Template CERT_CertificateTemplate[];
  845. extern const SEC_ASN1Template SEC_SignedCertificateTemplate[];
  846. extern const SEC_ASN1Template CERT_CertExtensionTemplate[];
  847. extern const SEC_ASN1Template CERT_SequenceOfCertExtensionTemplate[];
  848. extern const SEC_ASN1Template SECKEY_PublicKeyTemplate[];
  849. extern const SEC_ASN1Template CERT_SubjectPublicKeyInfoTemplate[];
  850. extern const SEC_ASN1Template CERT_TimeChoiceTemplate[];
  851. extern const SEC_ASN1Template CERT_ValidityTemplate[];
  852. extern const SEC_ASN1Template CERT_PublicKeyAndChallengeTemplate[];
  853. extern const SEC_ASN1Template SEC_CertSequenceTemplate[];
  854.  
  855. extern const SEC_ASN1Template CERT_IssuerAndSNTemplate[];
  856. extern const SEC_ASN1Template CERT_NameTemplate[];
  857. extern const SEC_ASN1Template CERT_SetOfSignedCrlTemplate[];
  858. extern const SEC_ASN1Template CERT_RDNTemplate[];
  859. extern const SEC_ASN1Template CERT_SignedDataTemplate[];
  860. extern const SEC_ASN1Template CERT_CrlTemplate[];
  861. extern const SEC_ASN1Template CERT_SignedCrlTemplate[];
  862.  
  863. /*
  864. ** XXX should the attribute stuff be centralized for all of ns/security?
  865. */
  866. extern const SEC_ASN1Template CERT_AttributeTemplate[];
  867. extern const SEC_ASN1Template CERT_SetOfAttributeTemplate[];
  868.  
  869. /* These functions simply return the address of the above-declared templates.
  870. ** This is necessary for Windows DLLs.  Sigh.
  871. */
  872. SEC_ASN1_CHOOSER_DECLARE(CERT_CertificateRequestTemplate)
  873. SEC_ASN1_CHOOSER_DECLARE(CERT_CertificateTemplate)
  874. SEC_ASN1_CHOOSER_DECLARE(CERT_CrlTemplate)
  875. SEC_ASN1_CHOOSER_DECLARE(CERT_IssuerAndSNTemplate)
  876. SEC_ASN1_CHOOSER_DECLARE(CERT_NameTemplate)
  877. SEC_ASN1_CHOOSER_DECLARE(CERT_SequenceOfCertExtensionTemplate)
  878. SEC_ASN1_CHOOSER_DECLARE(CERT_SetOfSignedCrlTemplate)
  879. SEC_ASN1_CHOOSER_DECLARE(CERT_SignedDataTemplate)
  880. SEC_ASN1_CHOOSER_DECLARE(CERT_SubjectPublicKeyInfoTemplate)
  881. SEC_ASN1_CHOOSER_DECLARE(SEC_SignedCertificateTemplate)
  882. SEC_ASN1_CHOOSER_DECLARE(CERT_SignedCrlTemplate)
  883. SEC_ASN1_CHOOSER_DECLARE(CERT_TimeChoiceTemplate)
  884.  
  885. SEC_END_PROTOS
  886.  
  887. #endif /* _CERTT_H_ */
  888.